home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / seyon / SeActions.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  11.4 KB  |  483 lines
  1.  
  2. /*
  3.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  4.  * Saggaf. All rights reserved.
  5.  *
  6.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  7.  * statement of rights and permissions for this program.
  8.  */
  9.  
  10. #include <stdlib.h>
  11. #include <unistd.h>
  12. #include <string.h>
  13. #include <math.h>
  14. #include <X11/Intrinsic.h>
  15. #include <X11/StringDefs.h>
  16. #include <X11/Xaw/Command.h>
  17.  
  18. /* SeDecl.h includes stdio.h */
  19. #include "SeDecl.h"
  20.  
  21. #define CheckNumParam(num) {if (*numParam != num) \
  22.   SimpleError("Wrong Number of Parameters");}
  23.  
  24. extern Widget   dialWidget;
  25.  
  26. void
  27. CallCallbacksAction(widget)
  28.      Widget          widget;
  29. {
  30.   XtCallCallbacks(widget, XtNdestroyCallback, NULL);
  31. }
  32.  
  33. void
  34. BeepAction(widget, event, param, numParam)
  35.      Widget          widget;
  36.      XEvent*         event;
  37.      String*         param;
  38.      Cardinal*       numParam;
  39. {
  40.   CheckNumParam(0);
  41.   Beep();
  42. }
  43.  
  44. void
  45. CloseWindowAction(widget, event, param, numParam)
  46.      Widget          widget;
  47.      XEvent*         event;
  48.      String*         param;
  49.      Cardinal*       numParam;
  50. {
  51.   int             DismissDirectory();
  52.   Widget          dirWidget;
  53.   int             i;
  54.  
  55.   for (i = 0; i < *numParam; i++) {
  56.     if (strcmp(param[i], "Dial") == 0)
  57.       {if ((dirWidget = XtNameToWidget(dialWidget, "directory")))
  58.          DismissDirectory(dirWidget);}
  59.     
  60.     else SimpleErrorF("Invalid Parameter `%s'", param[i], "", "");
  61.   } /* for... */
  62. }
  63.  
  64. void
  65. DialEntriesAction(widget, event, param, numParam)
  66.      Widget          widget;
  67.      XEvent*         event;
  68.      String*         param;
  69.      Cardinal*       numParam;
  70. {
  71.   ErrorIfBusy();
  72.   CheckNumParam(1);
  73.  
  74.   if (strcmp(*param, "Default")) TopDial(dialWidget, (XtPointer)*param);
  75.   else TopDial(dialWidget, (XtPointer)qres.defaultPhoneEntries);
  76. }
  77.  
  78. void
  79. DivertFileAction(widget, event, param, numParam)
  80.      Widget          widget;
  81.      XEvent*         event;
  82.      String*         param;
  83.      Cardinal*       numParam;
  84. {
  85.   void            DivertFile(),
  86.                   ExecDivertFile();
  87.          
  88.   ErrorIfBusy();
  89.   if (*numParam > 1)
  90.     SimpleError("Wrong Number of Parameters");
  91.  
  92.   if (*numParam == 0) DivertFile(widget);
  93.   else ExecDivertFile(widget, *param);
  94. }
  95.  
  96. void
  97. DoNothingAction(widget, event, param, numParam)
  98.      Widget          widget;
  99.      XEvent*         event;
  100.      String*         param;
  101.      Cardinal*       numParam;
  102. {
  103.   CheckNumParam(0);
  104. }
  105.  
  106. void
  107. EchoAction(widget, event, param, numParam)
  108.      Widget          widget;
  109.      XEvent*         event;
  110.      String*         param;
  111.      Cardinal*       numParam;
  112. {
  113.   if (*numParam == 0) show("");
  114.   CheckNumParam(1);
  115.   show(*param);
  116. }
  117.  
  118. void
  119. FileTransferAction(widget, event, param, numParam)
  120.      Widget          widget;
  121.      XEvent*         event;
  122.      String*         param;
  123.      Cardinal*       numParam;
  124. {
  125.   void            TopTransfer();
  126.   static String   pParam[2];
  127.   int             i;
  128.  
  129.   ErrorIfBusy();
  130.   if (*numParam < 1 || *numParam > 2)
  131.     SimpleError("Wrong Number of Parameters");
  132.  
  133.   for (i = 0; i < *numParam;) 
  134.     {pParam[i] = param[i]; pParam[++i] = NULL;}
  135.  
  136.   TopTransfer(widget, (XtPointer)pParam);
  137. }
  138.  
  139. void
  140. IconifyWindowAction(widget, event, param, numParam)
  141.      Widget          widget;
  142.      XEvent*         event;
  143.      String*         param;
  144.      Cardinal*       numParam;
  145. {
  146.   int             IconifyShell();
  147.   Widget          dirWidget;
  148.   static String   termWindowId = NULL;
  149.   int             i;
  150.  
  151.   for (i = 0; i < *numParam; i++) {
  152.     if (strcmp(param[i], "Main") == 0) IconifyShell(widget);
  153.  
  154.     else if (strcmp(param[i], "Dial") == 0)
  155.       {if ((dirWidget = XtNameToWidget(dialWidget, "directory")))
  156.          IconifyShell(dirWidget);}
  157.  
  158.     else if (strcmp(param[i], "Term") == 0) {
  159.       if (termWindowId == NULL) termWindowId = (String)getenv("WINDOWID");
  160.       if (termWindowId) 
  161.         XIconifyWindow(XtDisplay(widget), (Window)atol(termWindowId),
  162.                        XScreenNumberOfScreen(XtScreen(widget)));
  163.       else {
  164.         SeError("Could not get terminal window ID");
  165.         SeNotice("Maybe you're not using xterm?");
  166.         SimpleError("WINDOWID not Found");
  167.       }
  168.     } /* if strcmp Term... */
  169.  
  170.     else SimpleErrorF("Invalid Parameter `%s'", param[i], "", "");
  171.   } /* for... */
  172. }
  173.  
  174. void
  175. HangupAction(widget, event, param, numParam)
  176.      Widget          widget;
  177.      XEvent*         event;
  178.      String*         param;
  179.      Cardinal*       numParam;
  180. {
  181.   void            ExecHangup();
  182.  
  183.   ErrorIfBusy();
  184.   CheckNumParam(0);
  185.   ExecHangup();
  186. }
  187.  
  188. void
  189. ManualDialAction(widget, event, param, numParam)
  190.      Widget          widget;
  191.      XEvent*         event;
  192.      String*         param;
  193.      Cardinal*       numParam;
  194. {
  195.   void            ManualDial(),
  196.                   ExecManualDial();
  197.  
  198.   ErrorIfBusy();
  199.   if (*numParam > 1)
  200.     SimpleError("Wrong Number of Parameters");
  201.  
  202.   if (*numParam == 0) ManualDial(widget);
  203.   else ExecManualDial(widget, *param);
  204. }
  205.  
  206. void
  207. MessageAction(widget, event, param, numParam)
  208.      Widget          widget;
  209.      XEvent*         event;
  210.      String*         param;
  211.      Cardinal*       numParam;
  212. {
  213.   if (*numParam == 0) SeyonMessage("");
  214.   CheckNumParam(1);
  215.   SeyonMessage(*param);
  216. }
  217.  
  218. void
  219. OpenWindowAction(widget, event, param, numParam)
  220.      Widget          widget;
  221.      XEvent*         event;
  222.      String*         param;
  223.      Cardinal*       numParam;
  224. {
  225.   int             IconifyShell();
  226.   Widget          dirWidget;
  227.   static String   termWindowId = NULL;
  228.   int             i;
  229.  
  230.   for (i = 0; i < *numParam; i++) {
  231.     if (strcmp(param[i], "Main") == 0) XtMapWidget(GetShell(widget));
  232.  
  233.     else if (strcmp(param[i], "Dial") == 0)
  234.       if ((dirWidget = XtNameToWidget(dialWidget, "directory")))
  235.         {XtPopup(dirWidget, XtGrabNone); XtMapWidget(dirWidget);}
  236.       else TopDial(dialWidget, NULL);
  237.  
  238.     else if (strcmp(param[i], "Term") == 0) {
  239.       if (termWindowId == NULL) termWindowId = (String)getenv("WINDOWID");
  240.       if (termWindowId) 
  241.         XMapRaised(XtDisplay(widget), (Window)atol(termWindowId));
  242.       else {
  243.         SeError("Could not get terminal window ID");
  244.         SeNotice("Maybe you're not using xterm?");
  245.         SimpleError("WINDOWID not Found");
  246.       }
  247.     } /* if strcmp Term... */
  248.  
  249.     else SimpleErrorF("Invalid Parameter `%s'", param[i], "", "");
  250.   } /* for... */
  251. }
  252.  
  253. void
  254. QuitAction(widget, event, param, numParam)
  255.      Widget          widget;
  256.      XEvent*         event;
  257.      String*         param;
  258.      Cardinal*       numParam;
  259. {
  260.   ErrorIfBusy();
  261.   CheckNumParam(0);
  262.   ExecExit();
  263. }
  264.  
  265. void
  266. RestartTerminalAction(widget, event, param, numParam)
  267.      Widget          widget;
  268.      XEvent*         event;
  269.      String*         param;
  270.      Cardinal*       numParam;
  271. {
  272.   ErrorIfBusy();
  273.   CheckNumParam(0);
  274.   RestartTerminal();
  275. }
  276.  
  277. void
  278. RunScriptAction(widget, event, param, numParam)
  279.      Widget          widget;
  280.      XEvent*         event;
  281.      String*         param;
  282.      Cardinal*       numParam;
  283. {
  284.   void            DialogRunScript(),
  285.                   RunScript();
  286.            
  287.   ErrorIfBusy();
  288.   if (*numParam == 0) DialogRunScript(widget);
  289.   CheckNumParam(1);
  290.   RunScript(widget, *param);
  291. }
  292.  
  293. void
  294. SetAction(widget, event, param, numParam)
  295.      Widget          widget;
  296.      XEvent*         event;
  297.      String*         param;
  298.      Cardinal*       numParam;
  299. {
  300.   void            s_set();
  301.  
  302.   ErrorIfBusy();
  303.   CheckNumParam(2);
  304.   sprintf((lptr = line), "%s %s", param[0], param[1]);
  305.   eof_flag = 0;
  306.   s_set();
  307. }
  308.  
  309. void
  310. ShellCommandAction(widget, event, param, numParam)
  311.      Widget          widget;
  312.      XEvent*         event;
  313.      String*         param;
  314.      Cardinal*       numParam;
  315. {
  316.   ErrorIfBusy();
  317.   CheckNumParam(1);
  318.   ShellCommand(*param);
  319. }
  320.  
  321. void
  322. SleepAction(widget, event, param, numParam)
  323.      Widget          widget;
  324.      XEvent*         event;
  325.      String*         param;
  326.      Cardinal*       numParam;
  327. {
  328.   CheckNumParam(1);
  329.   sleep(atoi(*param));
  330. }
  331.  
  332. void
  333. TransmitAction(widget, event, param, numParam)
  334.      Widget          widget;
  335.      XEvent*         event;
  336.      String*         param;
  337.      Cardinal*       numParam;
  338. {
  339.   ErrorIfBusy();
  340.   CheckNumParam(1);
  341.   MdmPutString(*param);
  342. }
  343.  
  344. /*---------------------------------------------------------------------------+
  345. | DispatchActions - parses an action stack and dispatches its actions.
  346. +---------------------------------------------------------------------------*/
  347.  
  348. void
  349. DispatchActions(intData, stringData, widget)
  350.      int    intData;
  351.      String stringData;
  352.      Widget widget;
  353. {
  354.   int                 SeAppMSleep();
  355.   void                ParseThis();
  356.  
  357.   static Boolean      actionRunning = False,
  358.                       prevActionAsync = False,
  359.                       startup = True;
  360.   static Widget       actionWidget;
  361.   static String       actionStack;
  362.  
  363.   void                (*actionProc)();
  364.   static char         actionName[SM_BUF],
  365.                       args[SM_BUF][SM_BUF];
  366.   static String       argsArray[SM_BUF];
  367.   static Cardinal     numArgs;
  368.   int                 i;
  369.  
  370.   struct _actionTable {
  371.     String        actionKeyWord;
  372.     void          (*actionProc)();
  373.     Boolean       async;
  374.   };
  375.  
  376.   static struct _actionTable actionTable[] = {
  377.     {"Beep", BeepAction, False},
  378.     {"CloseWindow", CloseWindowAction, False},
  379.     {"DialEntries", DialEntriesAction, True},
  380.     {"DivertFile", DivertFileAction, True},
  381.     {"DoNothing", DoNothingAction, False},
  382.     {"Echo", EchoAction, False},
  383.     {"FileTransfer", FileTransferAction, True},
  384.     {"IconifyWindow", IconifyWindowAction, False},
  385.     {"Hangup", HangupAction, False},
  386.     {"ManualDial", ManualDialAction, True},
  387.     {"Message", MessageAction, False},
  388.     {"OpenWindow", OpenWindowAction, False},
  389.     {"Quit", QuitAction, False},
  390.     {"RestartTerminal", RestartTerminalAction, False},
  391.     {"RunScript", RunScriptAction, True},
  392.     {"Set", SetAction, False},
  393.     {"ShellCommand", ShellCommandAction, True},
  394.     {"Sleep", SleepAction, False},
  395.     {"Transmit", TransmitAction, False},
  396.     {NULL, NULL, False},
  397.   };
  398.  
  399.   switch (intData) {
  400.  
  401.   case ACTION_NEW_ACTION:
  402.     strcpy(actionName, stringData);
  403.     numArgs = 0;
  404.     return;
  405.  
  406.   case ACTION_NEW_ARG:
  407.     strcpy((argsArray[numArgs] = args[numArgs]), stringData);
  408.     numArgs++;
  409.     return;
  410.  
  411.   case ACTION_ARGS_END:
  412.     if (prevActionAsync) 
  413.       while(inhibit_child) 
  414.         XtAppProcessEvent(XtWidgetToApplicationContext(actionWidget), XtIMAll);
  415.  
  416.     for (i = 0; (actionProc = actionTable[i].actionProc) && 
  417.          strcmp(actionName, actionTable[i].actionKeyWord); i++);
  418.  
  419.     if (actionProc == NULL)
  420.       {SeError(FmtString("Invalid action: ``%s''", actionName, "", ""));
  421.        SimpleError("Invalid Action Specified");}
  422.  
  423.     (*actionProc)(actionWidget, NULL, argsArray, &numArgs);
  424.     prevActionAsync = actionTable[i].async;
  425.     return;
  426.  
  427.   case ACTION_PARSE_ERROR:
  428.     SeError(FmtString("%s in ``%s''", stringData, actionStack, ""));
  429.     return;
  430.  
  431.   case ACTION_DISPATCH:
  432.     if (actionRunning)
  433.       SimpleError("Action Still Running");
  434.     if (stringData == NULL) {
  435.       SeError("Serious (report it): stringData = NULL in DispatchActions");
  436.       return;
  437.     }
  438.  
  439.     actionWidget = widget;
  440.     actionStack = XtNewString(stringData);
  441.  
  442.     actionRunning = True;
  443.     prevActionAsync = False;
  444.     ParseThis(actionStack, DispatchActions);
  445.  
  446.     actionRunning = False;
  447.     XtFree(actionStack);
  448.  
  449.     if (startup) {
  450.       startup = False;
  451.       ParseThis(FmtString("Message(\"Welcome to Seyon version %s%s\"); %s",
  452.                           VERSION, REVISION, "RestartTerminal();"), 
  453.                 DispatchActions);
  454.     }
  455.       
  456.     return;
  457.   }
  458. }
  459.  
  460. /*---------------------------------------------------------------------------+
  461. | DispatchActionsCallback - callback for dispatching SeQuickKey actions.
  462. +---------------------------------------------------------------------------*/
  463.  
  464. void
  465. DispatchActionsCallback(widget, clientData)
  466.      XtPointer widget;
  467.      XtPointer clientData;
  468. {
  469.   void                GetQuickKeyResources();
  470.  
  471.   String              widgetName;
  472.   struct _quickKeyRes quickKeyRes;
  473.  
  474.   GetQuickKeyResources((widgetName = XtName(widget)), &quickKeyRes);  
  475.  
  476.   if (quickKeyRes.action == NULL || quickKeyRes.action[0] == '\0')
  477.     SimpleError("No Action Attached");
  478.  
  479.   DispatchActions(ACTION_DISPATCH, quickKeyRes.action, widget);
  480. }
  481.  
  482.  
  483.